Scikit-learnのフィーチャー選択：グローバルデータセットのための次元削減をマスターする

            
from sklearn.feature_selection import VarianceThreshold
import numpy as np

X = [[0, 2, 0, 3], [0, 1, 4, 3], [0, 1, 1, 3]]
selector = VarianceThreshold(threshold=0.0)
selector.fit_transform(X)
# Output: array([[2, 0, 3], [1, 4, 3], [1, 1, 3]])

            

              
                Copy
              
            
          

            
import pandas as pd
import numpy as np
from scipy.stats import pearsonr

# Sample data
data = {
    'feature1': np.random.rand(100),
    'feature2': np.random.rand(100) * 2,
    'feature3': np.random.rand(100) - 1,
    'target': np.random.randint(0, 2, 100)
}
df = pd.DataFrame(data)

# Calculate Pearson correlation with the target
correlations = df.corr()['target'].drop('target')

# Select features with correlation above a certain threshold (e.g., 0.2)
selected_features = correlations[abs(correlations) > 0.2].index.tolist()
print(f"Features correlated with target: {selected_features}")

            

              
                Copy
              
            
          

            
from sklearn.datasets import load_iris
from sklearn.feature_selection import SelectKBest, f_classif

iris = load_iris()
X, y = iris.data, iris.target

# Select the top 2 features using f_classif
selector = SelectKBest(score_func=f_classif, k=2)
X_new = selector.fit_transform(X, y)

print(f"Original shape: {X.shape}")
print(f"Reduced shape: {X_new.shape}")

# To see which features were selected:
selected_indices = selector.get_support(indices=True)
print(f"Selected feature indices: {selected_indices}")
print(f"Selected feature names: {[iris.feature_names[i] for i in selected_indices]}")

            

              
                Copy
              
            
          

            
from sklearn.datasets import make_classification
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

# Generate synthetic data
X, y = make_classification(n_samples=100, n_features=20, n_informative=10, n_redundant=5, random_state=42)

# Use a Logistic Regression model (can be any model that supports coef_ or feature_importances_)
estimator = LogisticRegression(solver='liblinear')

# Initialize RFE to select top 5 features
selector = RFE(estimator, n_features_to_select=5, step=1)
selector = selector.fit(X, y)

X_new = selector.transform(X)

print(f"Original shape: {X.shape}")
print(f"Reduced shape: {X_new.shape}")

# To see which features were selected:
selected_indices = selector.get_support(indices=True)
print(f"Selected feature indices: {selected_indices}")

            

              
                Copy
              
            
          

            
from sklearn.feature_selection import SequentialFeatureSelector
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import make_classification

X, y = make_classification(n_samples=100, n_features=20, n_informative=10, n_redundant=5, random_state=42)

estimator = LogisticRegression(solver='liblinear')

# Forward selection: add features until desired number is reached
sfs_forward = SequentialFeatureSelector(
    estimator, n_features_to_select=10, direction='forward', cv=5)
sfs_forward.fit(X, y)
X_new_forward = sfs_forward.transform(X)

print(f"Forward Selection - Reduced shape: {X_new_forward.shape}")

# Backward selection: start with all features and remove
sfs_backward = SequentialFeatureSelector(
    estimator, n_features_to_select=10, direction='backward', cv=5)
sfs_backward.fit(X, y)
X_new_backward = sfs_backward.transform(X)

print(f"Backward Selection - Reduced shape: {X_new_backward.shape}")

            

              
                Copy
              
            
          

            
from sklearn.linear_model import Lasso
from sklearn.datasets import make_regression

# Generate synthetic data
X, y = make_regression(n_samples=100, n_features=20, n_informative=10, random_state=42, noise=10)

# Lasso with alpha (regularization strength)
# A higher alpha leads to more regularization and potentially more zero coefficients
lasso = Lasso(alpha=0.1, random_state=42)
lasso.fit(X, y)

# Get the number of non-zero coefficients (selected features)
non_zero_features = np.sum(lasso.coef_ != 0)
print(f"Number of features selected by Lasso: {non_zero_features}")

# To get the actual selected features:
selected_features_mask = lasso.coef_ != 0
X_new = X[:, selected_features_mask]
print(f"Reduced shape: {X_new.shape}")

            

              
                Copy
              
            
          

            
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer

cancer = load_breast_cancer()
X, y = cancer.data, cancer.target

model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X, y)

# Get feature importances
importances = model.feature_importances_

# Sort features by importance
indices = np.argsort(importances)[::-1]

print("Feature ranking:")
for f in range(X.shape[1]):
    print(f"{f + 1}. feature {indices[f]} ({cancer.feature_names[indices[f]]}) - {importances[indices[f]]:.4f}")

# Select top N features (e.g., top 10)
N = 10
selected_features_mask = np.zeros(X.shape[1], dtype=bool)
selected_features_mask[indices[:N]] = True

X_new = X[:, selected_features_mask]
print(f"Reduced shape after selecting top {N} features: {X_new.shape}")

            

              
                Copy
              
            
          

            
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.datasets import load_wine

wine = load_wine()
X, y = wine.data, wine.target

# Scale the data
X_scaled = StandardScaler().fit_transform(X)

# Initialize PCA to reduce to 2 components
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)

print(f"Original shape: {X.shape}")
print(f"Reduced shape after PCA: {X_pca.shape}")

# The explained variance ratio shows how much variance each component captures
print(f"Explained variance ratio: {pca.explained_variance_ratio_}")
print(f"Total explained variance: {np.sum(pca.explained_variance_ratio_):.4f}")

            

              
                Copy
              
            
          

            
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import load_iris

iris = load_iris()
X, y = iris.data, iris.target

# Scale the data
X_scaled = StandardScaler().fit_transform(X)

# Initialize LDA. Number of components cannot exceed n_classes - 1 (which is 2 for Iris)
lda = LinearDiscriminantAnalysis(n_components=2)
X_lda = lda.fit_transform(X_scaled, y)

print(f"Original shape: {X.shape}")
print(f"Reduced shape after LDA: {X_lda.shape}")

# LDA also has explained_variance_ratio_ but it's class separability
print(f"Explained variance ratio (class separability): {lda.explained_variance_ratio_}")

            

              
                Copy
              
            
          

            
from sklearn.manifold import TSNE
from sklearn.datasets import load_digits
import matplotlib.pyplot as plt

digits = load_digits()
X, y = digits.data, digits.target

# For demonstration, we'll use a subset of the data as t-SNE can be slow
subset_indices = np.random.choice(len(X), 1000, replace=False)
X_subset = X[subset_indices]
y_subset = y[subset_indices]

# Initialize t-SNE with 2 components
# perplexity is related to the number of nearest neighbors (e.g., 30 is common)
# n_iter is the number of iterations for optimization
tsne = TSNE(n_components=2, perplexity=30, n_iter=300, random_state=42)
X_tsne = tsne.fit_transform(X_subset)

print(f"Original subset shape: {X_subset.shape}")
print(f"Reduced shape after t-SNE: {X_tsne.shape}")

# Plotting the results (optional, for visualization)
plt.figure(figsize=(10, 8))
scatter = plt.scatter(X_tsne[:, 0], X_tsne[:, 1], c=y_subset, cmap='viridis', alpha=0.7)
plt.title('t-SNE visualization of Digits dataset')
plt.xlabel('t-SNE component 1')
plt.ylabel('t-SNE component 2')
plt.legend(*scatter.legend_elements(), title='Classes')
plt.show()

            

              
                Copy
              
            
          

            
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.datasets import load_breast_cancer

bc = load_breast_cancer()
X, y = bc.data, bc.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Create a pipeline that first scales, then selects features, then trains a classifier
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('selector', SelectKBest(score_func=f_classif, k=10)),
    ('classifier', LogisticRegression(solver='liblinear'))
])

# Train the pipeline
pipe.fit(X_train, y_train)

# Evaluate the pipeline using cross-validation
cv_scores = cross_val_score(pipe, X_train, y_train, cv=5)
print(f"Cross-validation scores: {cv_scores}")
print(f"Average CV score: {np.mean(cv_scores):.4f}")

# Make predictions on the test set
accuracy = pipe.score(X_test, y_test)
print(f"Test set accuracy: {accuracy:.4f}")

            

              
                Copy